import config from '@/config'

/**
 * WiFi认证工具函数
 */

/**
 * 解析二维码中的设备ID
 * @param {string} qrResult 二维码扫描结果
 * @returns {string|null} 设备ID
 */
export function parseDeviceId(qrResult) {
  try {
    // 支持多种二维码格式
    // 格式1: deviceId=DEV-001
    // 格式2: https://domain.com/wifi?deviceId=DEV-001
    // 格式3: DEV-001
    
    if (qrResult.includes('deviceId=')) {
      const match = qrResult.match(/deviceId=([^&]+)/)
      return match ? decodeURIComponent(match[1]) : null
    }
    
    // 如果是URL格式
    if (qrResult.startsWith('http')) {
      const url = new URL(qrResult)
      return url.searchParams.get('deviceId')
    }
    
    // 直接是设备ID
    if (/^[A-Z0-9-]+$/.test(qrResult)) {
      return qrResult
    }
    
    return null
  } catch (error) {
    console.error('解析二维码失败：', error)
    return null
  }
}

/**
 * 验证设备ID格式
 * @param {string} deviceId 设备ID
 * @returns {boolean} 是否有效
 */
export function validateDeviceId(deviceId) {
  if (!deviceId || typeof deviceId !== 'string') {
    return false
  }
  
  // 设备ID格式：字母、数字、连字符，长度3-20
  return /^[A-Z0-9-]{3,20}$/.test(deviceId)
}

/**
 * 格式化剩余时间
 * @param {number} seconds 剩余秒数
 * @returns {string} 格式化后的时间字符串
 */
export function formatRemainingTime(seconds) {
  if (seconds <= 0) return '0秒'
  
  const hours = Math.floor(seconds / 3600)
  const minutes = Math.floor((seconds % 3600) / 60)
  const remainingSeconds = seconds % 60
  
  if (hours > 0) {
    return `${hours}时${minutes}分${remainingSeconds}秒`
  } else if (minutes > 0) {
    return `${minutes}分${remainingSeconds}秒`
  } else {
    return `${remainingSeconds}秒`
  }
}

/**
 * 获取认证状态文本
 * @param {string} status 状态码
 * @returns {string} 状态文本
 */
export function getAuthStatusText(status) {
  const statusMap = {
    'pending': '等待认证',
    'processing': '认证中',
    'success': '认证成功',
    'failed': '认证失败',
    'timeout': '认证超时',
    'expired': '会话过期'
  }
  
  return statusMap[status] || '未知状态'
}

/**
 * 获取广告类型文本
 * @param {string} type 广告类型
 * @returns {string} 类型文本
 */
export function getAdTypeText(type) {
  const typeMap = {
    'image': '图片广告',
    'video': '视频广告',
    'banner': '横幅广告',
    'popup': '弹窗广告'
  }
  
  return typeMap[type] || '未知类型'
}

/**
 * 创建会话存储key
 * @param {string} deviceId 设备ID
 * @param {string} suffix 后缀
 * @returns {string} 存储key
 */
export function createStorageKey(deviceId, suffix = '') {
  const prefix = 'wifi_auth'
  return suffix ? `${prefix}_${deviceId}_${suffix}` : `${prefix}_${deviceId}`
}

/**
 * 保存会话信息到本地
 * @param {string} deviceId 设备ID
 * @param {Object} sessionData 会话数据
 */
export function saveSessionData(deviceId, sessionData) {
  try {
    const key = createStorageKey(deviceId, 'session')
    const data = {
      ...sessionData,
      timestamp: Date.now(),
      deviceId: deviceId
    }
    uni.setStorageSync(key, JSON.stringify(data))
  } catch (error) {
    console.error('保存会话信息失败：', error)
  }
}

/**
 * 获取本地会话信息
 * @param {string} deviceId 设备ID
 * @returns {Object|null} 会话数据
 */
export function getSessionData(deviceId) {
  try {
    const key = createStorageKey(deviceId, 'session')
    const data = uni.getStorageSync(key)
    
    if (data) {
      const sessionData = JSON.parse(data)
      const now = Date.now()
      const expireTime = sessionData.timestamp + (config.wifiAuth.sessionTimeout * 1000)
      
      // 检查是否过期
      if (now < expireTime) {
        return sessionData
      } else {
        // 过期则删除
        uni.removeStorageSync(key)
        return null
      }
    }
    
    return null
  } catch (error) {
    console.error('获取会话信息失败：', error)
    return null
  }
}

/**
 * 清除会话信息
 * @param {string} deviceId 设备ID
 */
export function clearSessionData(deviceId) {
  try {
    const key = createStorageKey(deviceId, 'session')
    uni.removeStorageSync(key)
  } catch (error) {
    console.error('清除会话信息失败：', error)
  }
}

/**
 * 保存认证历史
 * @param {string} deviceId 设备ID
 * @param {Object} authRecord 认证记录
 */
export function saveAuthHistory(deviceId, authRecord) {
  try {
    const key = createStorageKey(deviceId, 'history')
    let history = []
    
    const existingData = uni.getStorageSync(key)
    if (existingData) {
      history = JSON.parse(existingData)
    }
    
    // 添加新记录
    history.unshift({
      ...authRecord,
      timestamp: Date.now(),
      deviceId: deviceId
    })
    
    // 最多保留50条记录
    if (history.length > 50) {
      history = history.slice(0, 50)
    }
    
    uni.setStorageSync(key, JSON.stringify(history))
  } catch (error) {
    console.error('保存认证历史失败：', error)
  }
}

/**
 * 获取认证历史
 * @param {string} deviceId 设备ID
 * @param {number} limit 返回记录数量限制
 * @returns {Array} 认证历史列表
 */
export function getAuthHistory(deviceId, limit = 10) {
  try {
    const key = createStorageKey(deviceId, 'history')
    const data = uni.getStorageSync(key)
    
    if (data) {
      const history = JSON.parse(data)
      return limit > 0 ? history.slice(0, limit) : history
    }
    
    return []
  } catch (error) {
    console.error('获取认证历史失败：', error)
    return []
  }
}

/**
 * 测试网络连接
 * @param {string} testUrl 测试URL
 * @param {number} timeout 超时时间（毫秒）
 * @returns {Promise<boolean>} 是否连通
 */
export function testNetworkConnection(testUrl = null, timeout = 5000) {
  const url = testUrl || config.wifiAuth.networkTestUrl
  
  return new Promise((resolve) => {
    uni.request({
      url: url,
      method: 'GET',
      timeout: timeout,
      success: () => {
        resolve(true)
      },
      fail: () => {
        resolve(false)
      }
    })
  })
}

/**
 * 格式化文件大小
 * @param {number} bytes 字节数
 * @returns {string} 格式化后的大小
 */
export function formatFileSize(bytes) {
  if (bytes === 0) return '0 B'
  
  const k = 1024
  const sizes = ['B', 'KB', 'MB', 'GB']
  const i = Math.floor(Math.log(bytes) / Math.log(k))
  
  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i]
}

/**
 * 防抖函数
 * @param {Function} func 要执行的函数
 * @param {number} wait 等待时间
 * @returns {Function} 防抖后的函数
 */
export function debounce(func, wait) {
  let timeout
  return function executedFunction(...args) {
    const later = () => {
      clearTimeout(timeout)
      func(...args)
    }
    clearTimeout(timeout)
    timeout = setTimeout(later, wait)
  }
}

/**
 * 节流函数
 * @param {Function} func 要执行的函数
 * @param {number} limit 时间间隔
 * @returns {Function} 节流后的函数
 */
export function throttle(func, limit) {
  let inThrottle
  return function executedFunction(...args) {
    if (!inThrottle) {
      func.apply(this, args)
      inThrottle = true
      setTimeout(() => inThrottle = false, limit)
    }
  }
} 